home *** CD-ROM | disk | FTP | other *** search
/ Aminet 33 / Aminet 33 - October 1999.iso / Aminet / util / misc / VMM_src.lha / VMM / rexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-16  |  10.3 KB  |  486 lines
  1. #include <exec/types.h>
  2. #include "defs.h"
  3. #include "Manager_Priv.h"
  4.  
  5. static char rcsid [] = "$Id: rexx.c,v 3.6 95/12/16 18:37:06 Martin_Apel Exp $";
  6.  
  7. #define isspace(c) (((c)==' ') || ((c) == '\t') || ((c) == '\n'))
  8.  
  9. #define RETURN_NO_MEM      -2
  10. #define RETURN_CMD_UNKNOWN -3
  11. #define RETURN_ARG_ERR     -4
  12.  
  13. PRIVATE char *On  = "ON",
  14.              *Off = "OFF";
  15.  
  16. /*********************************************************************/
  17.  
  18. PRIVATE UWORD RexxCommandNum (char *command)
  19.  
  20. {
  21. int i;
  22.  
  23. i = 0;
  24. while (RexxFuncs [i].FuncName != NULL)
  25.   {
  26.   if (Stricmp (command, RexxFuncs [i].FuncName) == 0)
  27.     return (RexxFuncs [i].FuncNum);
  28.   i++;
  29.   }
  30.  
  31. return (REXX_INV_CMD);
  32. }
  33.  
  34. /*********************************************************************/
  35.  
  36. PRIVATE BOOL ReadInt (struct RexxMsg *rmsg, int position, LONG *val)
  37.  
  38. {
  39. char buffer [50];
  40.  
  41. GetNthString (ARG0 (rmsg), buffer, position);
  42. if (StrToLong (buffer, val) == -1)
  43.   return (FALSE);
  44.  
  45. return (TRUE);
  46. }
  47.  
  48. /*********************************************************************/
  49.  
  50. PRIVATE BOOL CheckOnOff (char *buffer, BOOL *error)
  51.  
  52. {
  53. *error = FALSE;
  54.  
  55. if (Stricmp (buffer, On) == 0)
  56.   return (TRUE);
  57. if (Stricmp (buffer, Off) == 0)
  58.   return (FALSE);
  59.  
  60. *error = TRUE;
  61. return (FALSE);
  62. }
  63.  
  64. /*********************************************************************/
  65.  
  66. PRIVATE int RexxAddProg (struct RexxMsg *rmsg)
  67.  
  68. {
  69. char task_name [50],
  70.      buffer [30];
  71. LONG MinPublic,
  72.      MinNonPublic;
  73. BOOL CodePaging;
  74. BOOL ArgErr;
  75.  
  76. GetNthString (ARG0 (rmsg), task_name, 2);
  77. GetNthString (ARG0 (rmsg), buffer, 5);
  78. CodePaging = CheckOnOff (buffer, &ArgErr);
  79.  
  80. if ((task_name [0] == 0) || 
  81.     !ReadInt (rmsg, 3, &MinPublic) ||
  82.     !ReadInt (rmsg, 4, &MinNonPublic) ||
  83.     ArgErr)
  84.   return (RETURN_ARG_ERR);
  85.  
  86. EnterTask (task_name, MinPublic, MinNonPublic, CodePaging, INSERT_FRONT);
  87.  
  88. return (RETURN_OK);
  89. }
  90.  
  91. /*********************************************************************/
  92.  
  93. PRIVATE int RexxRemProg (struct RexxMsg *rmsg)
  94.  
  95. {
  96. char task_name [50];
  97.  
  98. GetNthString (ARG0 (rmsg), task_name, 2);
  99. if (task_name [0] == 0)
  100.   return (RETURN_ARG_ERR);
  101.  
  102. RemoveTask (task_name);
  103.  
  104. return (RETURN_OK);
  105. }
  106.  
  107. /*********************************************************************/
  108.  
  109. PRIVATE int RexxPatchWB (struct RexxMsg *rmsg)
  110.  
  111. {
  112. char param [30];
  113. BOOL ArgErr;
  114. BOOL PatchWB;
  115.  
  116. GetNthString (ARG0 (rmsg), param, 2);
  117.  
  118. PatchWB = CheckOnOff (param, &ArgErr);
  119. if (ArgErr)
  120.   return (RETURN_ARG_ERR);
  121.  
  122. CurrentConfig.PatchWB = PatchWB;  
  123. if (CurrentConfig.PatchWB && (OrigSetWindowTitles == NULL))
  124.   {
  125.   PRINT_DEB ("Patching SetWindowTitles ()", 0L);
  126.   OrigSetWindowTitles = (void (*) ()) SetFunction ((struct Library*)IntuitionBase,
  127.                                      -0x114, (ULONG (*) ()) SetWindowTitlesPatch);
  128.   }
  129. else if (!CurrentConfig.PatchWB && (OrigSetWindowTitles != NULL))
  130.   {
  131.   SetFunction ((struct Library*)IntuitionBase, -0x114, 
  132.                (ULONG (*) ()) OrigSetWindowTitles);
  133.   OrigSetWindowTitles = NULL;
  134.   }
  135.  
  136. return (RETURN_OK);
  137. }
  138.  
  139. /*********************************************************************/
  140.  
  141. PRIVATE int RexxMemTrack (struct RexxMsg *rmsg)
  142.  
  143. {
  144. char param [30];
  145. BOOL ArgErr;
  146. BOOL TmpMemTracking;
  147.  
  148. GetNthString (ARG0 (rmsg), param, 2);
  149.  
  150. TmpMemTracking = CheckOnOff (param, &ArgErr);
  151. if (ArgErr)
  152.   return (RETURN_ARG_ERR);
  153.  
  154. CurrentConfig.MemTracking = MemTracking = TmpMemTracking;
  155. return (RETURN_OK);
  156. }
  157.  
  158. /*********************************************************************/
  159.  
  160. PRIVATE int RexxMinVMAlloc (struct RexxMsg *rmsg)
  161.  
  162. {
  163. LONG val;
  164.  
  165. if (!ReadInt (rmsg, 2, &val) || (val < 0))
  166.   return (RETURN_ARG_ERR);
  167.  
  168. CurrentConfig.MinVMAlloc = MinVMAlloc = val;
  169.  
  170. return (RETURN_OK);
  171. }
  172.  
  173. /*********************************************************************/
  174.  
  175. struct
  176.   {
  177.   char *keyword,
  178.        *answer;
  179.   } InfoVals [] =
  180.   { 
  181.     { "title", PROGNAME },
  182.     { "author", AUTHOR },
  183.     { "copyright", COPYRIGHT },
  184.     { "description", DESCRIPTION },
  185.     { "version", VER_STRING },
  186.     { "base", PROGNAME },
  187.     { "screen", NULL },
  188.     { NULL, NULL }
  189.   };
  190.   
  191. /*********************************************************************/
  192.  
  193. PRIVATE int RexxInfo (struct RexxMsg *rmsg)
  194.  
  195. {
  196. char param [30];
  197. int i = 0;
  198.  
  199. GetNthString (ARG0 (rmsg), param, 2);
  200.  
  201. while (InfoVals [i].keyword != NULL)
  202.   {
  203.   if (Stricmp (param, InfoVals [i].keyword) == 0)
  204.     {
  205.     if (InfoVals [i].answer == NULL)
  206.       rmsg->rm_Result2 = NULL;
  207.     else
  208.       rmsg->rm_Result2 = (LONG)CreateArgstring (InfoVals [i].answer,
  209.                                     (ULONG)strlen (InfoVals [i].answer));
  210.     return (RETURN_OK);
  211.     }
  212.   i++;
  213.   }
  214.  
  215. return (RETURN_ARG_ERR);
  216. }
  217.  
  218. /*********************************************************************/
  219.  
  220. PRIVATE int RexxStat (struct RexxMsg *rmsg)
  221.  
  222. {
  223. char param [30];
  224. int rc;
  225. BOOL ArgErr;
  226. BOOL enable;
  227.  
  228. GetNthString (ARG0 (rmsg), param, 2);
  229. enable = CheckOnOff (param, &ArgErr);
  230. if (ArgErr)
  231.   return (RETURN_ARG_ERR);
  232.  
  233. CurrentConfig.StatEnabled = enable;
  234. if (CurrentConfig.StatEnabled && (FindTask (STAT_NAME) == NULL))
  235.   {
  236.   if ((rc = LaunchStat ()) != SUCCESS)
  237.     {
  238.     RunTimeError (rc);
  239.     return (RETURN_ERROR);
  240.     }
  241.   }
  242. else if (!CurrentConfig.StatEnabled && (FindTask (STAT_NAME) != NULL))
  243.   Signal (StatTask, 1L << StatQuitSignal);
  244.  
  245. return (RETURN_OK);
  246. }
  247.  
  248. /*********************************************************************/
  249.  
  250. PRIVATE int RexxZoom (struct RexxMsg *rmsg)
  251.  
  252. {
  253. char param [30];
  254. BOOL ArgErr;
  255. BOOL zoom;
  256.  
  257. GetNthString (ARG0 (rmsg), param, 2);
  258. zoom = CheckOnOff (param, &ArgErr);
  259. if (ArgErr)
  260.   return (RETURN_ARG_ERR);
  261.  
  262. CurrentConfig.StatZoomed = zoom;
  263. return (RETURN_OK);
  264. }
  265.  
  266. /*********************************************************************/
  267.  
  268. PRIVATE int RexxMem (struct RexxMsg *rmsg)
  269.  
  270. {
  271. ULONG MinMem,
  272.       MaxMem;
  273. struct VMMsg *ConfigMsg;
  274.  
  275. if (!ReadInt (rmsg, 2, (LONG*)&MinMem) ||
  276.     !ReadInt (rmsg, 3, (LONG*)&MaxMem))
  277.   return (RETURN_ARG_ERR);
  278.  
  279. MinMem = ALIGN_DOWN (MinMem, PAGESIZE);
  280. MaxMem = ALIGN_DOWN (MaxMem, PAGESIZE);
  281. if (MinMem < MAX_FAULTS * PAGESIZE)
  282.   MinMem = MAX_FAULTS * PAGESIZE;
  283.  
  284. if (MaxMem < MinMem)
  285.   MaxMem = MinMem;
  286.  
  287. CurrentConfig.MinMem = MinMem;
  288. CurrentConfig.MaxMem = MaxMem;
  289.  
  290. if ((ConfigMsg = DoOrigAllocMem (sizeof (struct VMMsg), MEMF_PUBLIC)) == NULL)
  291.   return (RETURN_NO_MEM);
  292.  
  293. ConfigMsg->VMCommand = VMCMD_NewConfig;
  294. ConfigMsg->ReplySignal = NULL;
  295. ConfigMsg->VMSender = (struct Task*)VM_ManagerProcess;
  296. PutMsg (PageHandlerPort, (struct Message*) ConfigMsg);
  297.  
  298. return (RETURN_OK);
  299. }
  300.  
  301. /*********************************************************************/
  302.  
  303. PRIVATE int RexxMemType (struct RexxMsg *rmsg)
  304.  
  305. {
  306. ULONG flags;
  307.  
  308. if (!ReadInt (rmsg, 2, (LONG*)&flags))
  309.   return (RETURN_ARG_ERR);
  310.  
  311. CurrentConfig.MemFlags = flags;
  312.  
  313. return (RETURN_OK);
  314. }
  315.  
  316. /*********************************************************************/
  317.  
  318. PRIVATE int RexxWriteBuffer (struct RexxMsg *rmsg)
  319.  
  320. {
  321. if (!ReadInt (rmsg, 2, (LONG*)&DesiredWriteBufferSize))
  322.   return (RETURN_ARG_ERR);
  323.  
  324. DISABLE_VM;
  325. CreateTask (WBUF_ALLOC_NAME, 5L, AllocNewCache, 1000L);
  326. ENABLE_VM;
  327.  
  328. return (RETURN_OK);
  329. }
  330.  
  331. /*********************************************************************/
  332.  
  333. PRIVATE int RexxVMPri (struct RexxMsg *rmsg)
  334.  
  335. {
  336. LONG pri;
  337.  
  338. if (!ReadInt (rmsg, 2, &pri) || (pri < -128) || (pri > 127))
  339.   return (RETURN_ARG_ERR);
  340.  
  341. CurrentConfig.VMPriority = pri;
  342.  
  343. Forbid ();
  344. if (VirtMem->mh_Node.ln_Name != NULL)      
  345.   {
  346.   Remove ((struct Node*)VirtMem);
  347.   VirtMem->mh_Node.ln_Pri = CurrentConfig.VMPriority;
  348.   Enqueue (&(SysBase->MemList), (struct Node*)VirtMem);
  349.   }
  350. Permit ();
  351.  
  352. return (RETURN_OK);
  353. }
  354.  
  355. /*********************************************************************/
  356.  
  357. PRIVATE int RexxHelp (struct RexxMsg *rmsg)
  358.  
  359. {
  360. char filename [100];
  361. BPTR HelpFile;
  362. struct RexxFuncEntry *rfe;
  363.  
  364. GetNthString (ARG0 (rmsg), filename, 2);
  365. if (filename [0] == 0)
  366.   return (RETURN_ARG_ERR);
  367.  
  368. DISABLE_VM;
  369. if ((HelpFile = Open (filename, MODE_NEWFILE)) == NULL)
  370.   {
  371.   ENABLE_VM;
  372.   return (RETURN_NO_MEM);
  373.   }
  374.  
  375. rfe = &(RexxFuncs [0]);
  376. while (rfe->FuncName != NULL)
  377.   {
  378.   FPrintf (HelpFile, "%s\n", rfe->FuncName);
  379.   rfe++;
  380.   }
  381.  
  382. Close (HelpFile);
  383.  
  384. ENABLE_VM;
  385. return (RETURN_OK);
  386. }
  387.  
  388. /*********************************************************************/
  389.  
  390. BOOL HandleRexxMsg (void)
  391.  
  392. {
  393. int primary;
  394. BOOL Quit = FALSE;
  395. int rc;
  396. char cmd [30];
  397. struct RexxMsg *rmsg;
  398.  
  399. while ((rmsg = (struct RexxMsg*)GetMsg (RexxPort)) != NULL)
  400.   {
  401.   GetNthString (ARG0 (rmsg), cmd, 1);
  402.  
  403.   PRINT_DEB ("Received RexxMsg", 0L);
  404.  
  405.   primary = RETURN_OK;
  406.   PRINT_DEB ("cmdname is ", 0L);
  407.   PRINT_DEB (cmd, 0L);
  408.   rmsg->rm_Result2 = NULL;
  409.   switch (RexxCommandNum (cmd))
  410.     {
  411.     case REXX_INV_CMD: primary = RETURN_CMD_UNKNOWN; break;
  412.  
  413.     case REXX_ADDPROG: primary = RexxAddProg (rmsg);
  414.                        break;
  415.  
  416.     case REXX_REMPROG: primary = RexxRemProg (rmsg);
  417.                        break;
  418.  
  419.     case REXX_ENABLE:  if (!VMEnabled)
  420.                          {
  421.                          VMEnabled = TRUE;
  422.                          ENABLE_VM;
  423.                          }
  424.                        break;
  425.  
  426.     case REXX_DISABLE: if (VMEnabled)
  427.                          {
  428.                          VMEnabled = FALSE;
  429.                          DISABLE_VM;
  430.                          }
  431.                        break;
  432.  
  433.     case REXX_QUIT:    if (TryToQuit ())
  434.                          Quit = TRUE;
  435.                        break;
  436.  
  437.     case REXX_HIDE:    HideGUI ();
  438.                        break;
  439.  
  440.     case REXX_SHOW:    if ((rc = ShowGUI ()) != SUCCESS)
  441.                          {
  442.                          RunTimeError (rc);
  443.                          primary = RETURN_ERROR;
  444.                          }
  445.                        break;
  446.  
  447.     case REXX_INFO:    primary = RexxInfo (rmsg);
  448.                        break;
  449.  
  450.     case REXX_STAT:    primary = RexxStat (rmsg);
  451.                        break;
  452.  
  453.     case REXX_MEM:     primary = RexxMem (rmsg);
  454.                        break;
  455.  
  456.     case REXX_MEMTYPE: primary = RexxMemType (rmsg);
  457.  
  458.     case REXX_WRITEBUFFER: primary = RexxWriteBuffer (rmsg);
  459.                            break;
  460.  
  461.     case REXX_VMPRI:      primary = RexxVMPri (rmsg);
  462.                           break;
  463.  
  464.     case REXX_PATCHWB:    primary = RexxPatchWB (rmsg);
  465.                           break;
  466.  
  467.     case REXX_MEMTRACK:   primary = RexxMemTrack (rmsg);
  468.                           break;
  469.  
  470.     case REXX_MINVMALLOC: primary = RexxMinVMAlloc (rmsg);
  471.                           break;
  472.  
  473.     case REXX_HELP:       primary = RexxHelp (rmsg);
  474.                           break;
  475.  
  476.     case REXX_ZOOM:       primary = RexxZoom (rmsg);
  477.                           break;
  478.     }
  479.   
  480.   rmsg->rm_Result1 = primary;
  481.   ReplyMsg ((struct Message*)rmsg);
  482.   }
  483.  
  484. return (Quit);
  485. }
  486.